﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace sjt_console20200527
{
    class Program
    {
        static void Main(string[] args)
        {
            //数组
            //test01();
            // 二维数组
            //test02();
            // 二维数的声明方式2
            //test03();
            // Array工具类的使用
            test04();
            /// 暂停
            Console.Read();
        }
        /// <summary>
        /// 数组Array工具类的应用
        /// </summary>
        static void test04()
        {
            // 声明定义一个数组
            int[] arr0 = new int[] { 4,2,3,1,8,7};
            Console.WriteLine("排序之前数组内容：");
            printArr(arr0);
            // 对数组元素进行排序
            Array.Sort(arr0);
            Console.WriteLine("排序之后数组内容：");
            printArr(arr0);
        }

        /// <summary>
        /// 打印一维数组的元素
        /// </summary>
        static void printArr(int[] arr)
        {
            // for循环进行数组遍历
            foreach (int val in arr)  /// 避免数组越界；没有了遍历下标，不知道当前遍历到了那个元素
            {
                Console.Write("   {0}", val);
            }
            // 换行符
            Console.WriteLine();
        }
        /// <summary>
        /// 数组的应用-二维数组声明初始化方式2
        /// </summary>
        static void test03()
        {
            // 二维数组的声明方式1
            int[][] arr100;
            // 分配内存空间并初始化
            arr100 = new int[3][]; // 不需要给定列，但是需要初始化处理 同arr102的初始化方式

            //arr100 = new int[][] { { 1, 2, 3 }, { 4, 5, 6 } }; // 不能够分开初始化

            //int[][] arr101 = new int[][]{ { 1, 2, 3 }, { 4, 5, 6 } }; // 不能直接使用{}赋值初始化

            // 分开声明
            int[][] arr102 = new int[3][]; // 只给定了行数，没有给定列数，需要使用一维数组来初始化这一行的列数
            // 接着继续将每一列初始化完成
            arr102[0] = new int[] { 1, 2 }; // arr102[0] 表示的是第一行，使用一个一维数组进行初始化
            arr102[1] = new int[] { 4, 5, 6 };//
            arr102[2] = new int[] { 4, 5, 6,7 };

            // 获取二维数组的行和列
            Console.WriteLine("数组的元素个数：行数：{0}，列数：{1}", arr102.Length, arr102[1].Length);

            //Console.WriteLine("22数组的元素个数：{2}，行数：{0}，列数：{1}", arr102.GetLength(0));

            Console.WriteLine("使用双层for循环遍历数组：");
            // 外层for循环遍历行数：

            for (int i = 0; i < arr102.Length; i++) // 下标容易越界；有遍历下标，知道当前遍历到了那个一个元素
            {
                // 内层for循环遍历数组的列数
                for (int j = 0; j < arr102[i].Length; j++)
                {
                    // 输出对应行和列的元素的个数
                    Console.Write("   {0}", arr102[i][j]);
                }
                // 换行
                Console.WriteLine();
            }

            // foreach增强相的for循环
            Console.WriteLine("使用foreach循环遍历数组：");
            // for循环进行数组遍历
            // 第一层foreach循环遍历的二维数组中的每一行的对象（将一行作为一个整体进行处理）
            foreach (int[] val in arr102)  /// 避免数组越界；没有了遍历下标，不知道当前遍历到了那个元素
            {
                // 第二层foreach遍历的是每一行中的元素
                foreach (int i in val)
                {
                    Console.Write("   {0}", i);
                }
                // 换行
                Console.WriteLine();
            }

        }

            /// <summary>
            /// 数组的应用-二维数组
            /// </summary>
            static void test02()
        {
            
            // 二维数组的声明方式2
            int[,] arr0;            
            // 数组的初始化
            int[,] arr1 = { { 1,2,3} , {4,5,6 }, {7,8,9 } }; // {}直接初始化的方式必须和声明同时进行，不能分开进行 
            arr0 = new int[3,4];  // 使用new分配存储空间
            int[,] arr2;
            arr2 = new int[,] { { 1, 2, 3,3 }, { 4, 5, 6,6 }, { 7, 8,9,8} }; // 推荐使用这种方式 

            int[,] arr3 = new int[3,3] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };// 要求[]中定义的数组的长度和{}中初始化赋值的元素个数保持一致

            Console.WriteLine("使用双层for循环遍历数组：");
            // 动态获取二维数组的行和列的值
            Console.WriteLine("数组的元素个数：{2}，行数：{0}，列数：{1}",arr2.GetLength(0), arr2.GetLength(1),arr2.Length);
            // for循环进行数组遍历
            // arr2.GetLength(0)表示数组的行数；arr2.GetLength(1)表示数组的列数；
            // 外层for循环遍历行数：

            for (int i = 0; i < arr2.GetLength(0); i++) // 下标容易越界；有遍历下标，知道当前遍历到了那个一个元素
            {
                // 内层for循环遍历数组的列数
                for (int j=0;j< arr2.GetLength(1);j++)
                {
                    // 输出对应行和列的元素的个数
                    Console.Write("   {0}", arr2[i,j]);
                }
                // 换行
                Console.WriteLine();
            }
            
            // 换行符
            Console.WriteLine();
            // foreach增强相的for循环
            Console.WriteLine("使用foreach循环遍历数组：");
            // for循环进行数组遍历
            foreach (int val in arr2)  /// 避免数组越界；没有了遍历下标，不知道当前遍历到了那个元素
            {
                Console.Write("   {0}", val);
            }

            // 换行符
            Console.WriteLine();
        }
    
    /// <summary>
    /// 数组的应用-一维数组
    /// </summary>
    static void test01()
        {
            // 数组的声明
            int[] arr0;
            //int arr0[]; // C语言的声明方式是不支持的
            // 数组的初始化
            int[] arr1 = {1,2,3 }; // {}直接初始化的方式必须和声明同时进行，不能分开进行 
            arr0 = new int[3];  // 使用new分配存储空间
            int[] arr2;
            arr2 = new int[] { 4,5,6};

            int[] arr3 = new int[3] { 7,8,9};// 要求[]中定义的数组的长度和{}中初始化赋值的元素个数保持一致

            Console.WriteLine("使用for循环遍历数组：");
            // for循环进行数组遍历
            for (int i=0;i<arr2.Length;i++) // 下标容易越界；有遍历下标，知道当前遍历到了那个一个元素
            {
                Console.Write("   {0}",arr2[i]);
            }
            // 换行符
            Console.WriteLine();
            // foreach增强相的for循环
            Console.WriteLine("使用foreach循环遍历数组：");
            // for循环进行数组遍历
            foreach (int val in arr2)  /// 避免数组越界；没有了遍历下标，不知道当前遍历到了那个元素
            {
                Console.Write("   {0}", val);
            }

            // 换行符
            Console.WriteLine();
        }
    }
}
